home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / OCEMessaging.p < prev    next >
Encoding:
Text File  |  1997-08-12  |  30.7 KB  |  1,177 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        OCEMessaging.p
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1994-1997 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT OCEMessaging;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __OCEMESSAGING__}
  28. {$SETC __OCEMESSAGING__ := 1}
  29.  
  30. {$I+}
  31. {$SETC OCEMessagingIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __FILES__}
  35. {$I Files.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40.  
  41. {$IFC UNDEFINED __DIGITALSIGNATURE__}
  42. {$I DigitalSignature.p}
  43. {$ENDC}
  44. {$IFC UNDEFINED __OCE__}
  45. {$I OCE.p}
  46. {$ENDC}
  47. {$IFC UNDEFINED __OCEAUTHDIR__}
  48. {$I OCEAuthDir.p}
  49. {$ENDC}
  50.  
  51.  
  52. {$PUSH}
  53. {$ALIGN MAC68K}
  54. {$LibExport+}
  55.  
  56. {****************************************************************************}
  57. { Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  58. message ids and priorities, etc. }
  59.  
  60. { Values of IPMPriority }
  61.  
  62. CONST
  63.     kIPMAnyPriority                = 0;                            {  FOR FILTER ONLY  }
  64.     kIPMNormalPriority            = 1;
  65.     kIPMLowPriority                = 2;
  66.     kIPMHighPriority            = 3;
  67.  
  68.  
  69. TYPE
  70.     IPMPriority                            = Byte;
  71. { Values of IPMAccessMode }
  72.  
  73. CONST
  74.     kIPMAtMark                    = 0;
  75.     kIPMFromStart                = 1;
  76.     kIPMFromLEOM                = 2;
  77.     kIPMFromMark                = 3;
  78.  
  79.  
  80. TYPE
  81.     IPMAccessMode                        = INTEGER;
  82.  
  83. CONST
  84.     kIPMUpdateMsgBit            = 4;
  85.     kIPMNewMsgBit                = 5;
  86.     kIPMDeleteMsgBit            = 6;
  87.  
  88. { Values of IPMNotificationType }
  89.     kIPMUpdateMsgMask            = $10;
  90.     kIPMNewMsgMask                = $20;
  91.     kIPMDeleteMsgMask            = $40;
  92.  
  93.  
  94. TYPE
  95.     IPMNotificationType                    = Byte;
  96. { Values of IPMSenderTag }
  97.  
  98. CONST
  99.     kIPMSenderRStringTag        = 0;
  100.     kIPMSenderRecordIDTag        = 1;
  101.  
  102.  
  103. TYPE
  104.     IPMSenderTag                        = INTEGER;
  105.  
  106. CONST
  107.     kIPMFromDistListBit            = 0;
  108.     kIPMDummyRecBit                = 1;
  109.     kIPMFeedbackRecBit            = 2;                            {  should be redirected to feedback queue  }
  110.     kIPMReporterRecBit            = 3;                            {  should be redirected to reporter original queue  }
  111.     kIPMBCCRecBit                = 4;                            {  this recipient is blind to all recipients of message  }
  112.  
  113. { Values of OCERecipientOffsetFlags }
  114.     kIPMFromDistListMask        = $01;
  115.     kIPMDummyRecMask            = $02;
  116.     kIPMFeedbackRecMask            = $04;
  117.     kIPMReporterRecMask            = $08;
  118.     kIPMBCCRecMask                = $10;
  119.  
  120.  
  121. TYPE
  122.     OCERecipientOffsetFlags                = Byte;
  123.     OCECreatorTypePtr = ^OCECreatorType;
  124.     OCECreatorType = RECORD
  125.         msgCreator:                OSType;
  126.         msgType:                OSType;
  127.     END;
  128.  
  129.  
  130. CONST
  131.     kIPMTypeWildCard            = 'ipmw';
  132.     kIPMFamilyUnspecified        = 0;
  133.     kIPMFamilyWildCard            = $3F3F3F3F;                    {  '????' * well known signature  }
  134.     kIPMSignature                = 'ipms';                        {  base type * well known message types  }
  135.     kIPMReportNotify            = 'rptn';                        {  routing feedback * well known message block types  }
  136.     kIPMEnclosedMsgType            = 'emsg';                        {  enclosed (nested) message  }
  137.     kIPMReportInfo                = 'rpti';                        {  recipient information  }
  138.     kIPMDigitalSignature        = 'dsig';                        {  digital signature  }
  139.  
  140. { Values of IPMMsgFormat }
  141.     kIPMOSFormatType            = 1;
  142.     kIPMStringFormatType        = 2;
  143.  
  144.  
  145. TYPE
  146.     IPMMsgFormat                        = INTEGER;
  147.     IPMStringMsgType                    = Str32;
  148.     TheTypePtr = ^TheType;
  149.     TheType = RECORD
  150.         CASE INTEGER OF
  151.         0: (
  152.             msgOSType:            OCECreatorType;
  153.             );
  154.         1: (
  155.             msgStrType:            IPMStringMsgType;
  156.             );
  157.     END;
  158.  
  159.     IPMMsgTypePtr = ^IPMMsgType;
  160.     IPMMsgType = RECORD
  161.         format:                    IPMMsgFormat;                            {  IPMMsgFormat }
  162.         theType:                TheType;
  163.     END;
  164.  
  165. {
  166. Following are the known extension values for IPM addresses handled by Apple.
  167. We define the definition of the entn extension below.
  168. }
  169.  
  170. CONST
  171.     kOCEalanXtn                    = 'alan';
  172.     kOCEentnXtn                    = 'entn';                        {  entn = entity name (aka DSSpec)  }
  173.     kOCEaphnXtn                    = 'aphn';
  174.  
  175. {
  176. Following are the specific definitions for the extension for the standard
  177. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  178. IPMEntityNameExtension.]
  179. }
  180. { entn extension forms }
  181.     kOCEAddrXtn                    = 'addr';
  182.     kOCEQnamXtn                    = 'qnam';
  183.     kOCEAttrXtn                    = 'attr';                        {  an attribute specification  }
  184.     kOCESpAtXtn                    = 'spat';                        {  specific attribute  }
  185.  
  186. {
  187. Following are the specific definitions for standard
  188. OCEMail 'aphn' extension value.  
  189.  
  190. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  191. if length odd, then a pad byte (zero) should be introduced before the next field).
  192.  
  193. The extension value is in the packed form of the following structure:
  194.     RString        phoneNumber;
  195.     RString        modemType;
  196.     Str32        queueuName;
  197.  
  198. The body of phoneNumber compound RString is in the packed form of the following structure:
  199.     short         subType;
  200.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  201.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  202.     RString        phone;                        // used when subType == kOCEUseHandyDial
  203.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  204.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  205. }
  206. { phoneNumber sub type constants }
  207.     kOCEUseHandyDial            = 1;
  208.     kOCEDontUseHandyDial        = 2;
  209.  
  210. { FORMAT OF A PACKED FORM RECIPIENT }
  211.  
  212. TYPE
  213.     ProtoOCEPackedRecipientPtr = ^ProtoOCEPackedRecipient;
  214.     ProtoOCEPackedRecipient = RECORD
  215.         dataLength:                INTEGER;
  216.     END;
  217.  
  218.  
  219. CONST
  220.     kOCEPackedRecipientMaxBytes    = 4094;
  221.  
  222.  
  223. TYPE
  224.     OCEPackedRecipientPtr = ^OCEPackedRecipient;
  225.     OCEPackedRecipient = RECORD
  226.         dataLength:                INTEGER;
  227.         data:                    PACKED ARRAY [0..4093] OF Byte;
  228.     END;
  229.  
  230.     IPMEntnQueueExtensionPtr = ^IPMEntnQueueExtension;
  231.     IPMEntnQueueExtension = RECORD
  232.         queueName:                Str32;
  233.     END;
  234.  
  235. { kOCEAttrXtn }
  236.     IPMEntnAttributeExtensionPtr = ^IPMEntnAttributeExtension;
  237.     IPMEntnAttributeExtension = RECORD
  238.         attributeName:            AttributeType;
  239.     END;
  240.  
  241. { kOCESpAtXtn }
  242.     IPMEntnSpecificAttributeExtensionPtr = ^IPMEntnSpecificAttributeExtension;
  243.     IPMEntnSpecificAttributeExtension = RECORD
  244.         attributeCreationID:    AttributeCreationID;
  245.         attributeName:            AttributeType;
  246.     END;
  247.  
  248. { All IPM entn extensions fit within the following }
  249.     IPMEntityNameExtensionPtr = ^IPMEntityNameExtension;
  250.     IPMEntityNameExtension = RECORD
  251.         subExtensionType:        OSType;
  252.         CASE INTEGER OF
  253.         0: (
  254.             specificAttribute:    IPMEntnSpecificAttributeExtension;
  255.             );
  256.         1: (
  257.             attribute:            IPMEntnAttributeExtension;
  258.             );
  259.         2: (
  260.             queue:                IPMEntnQueueExtension;
  261.             );
  262.     END;
  263.  
  264. { addresses with kIPMNBPXtn should specify this nbp type }
  265.     IPMMsgIDPtr = ^IPMMsgID;
  266.     IPMMsgID = RECORD
  267.         id:                        ARRAY [0..3] OF LONGINT;
  268.     END;
  269.  
  270.  
  271. { Values of IPMHeaderSelector }
  272.  
  273. CONST
  274.     kIPMTOC                        = 0;
  275.     kIPMSender                    = 1;
  276.     kIPMProcessHint                = 2;
  277.     kIPMMessageTitle            = 3;
  278.     kIPMMessageType                = 4;
  279.     kIPMFixedInfo                = 7;
  280.  
  281.  
  282. TYPE
  283.     IPMHeaderSelector                    = Byte;
  284.     TheSenderPtr = ^TheSender;
  285.     TheSender = RECORD
  286.         CASE INTEGER OF
  287.         0: (
  288.             rString:            RString;
  289.             );
  290.         1: (
  291.             rid:                PackedRecordID;
  292.             );
  293.     END;
  294.  
  295.     IPMSenderPtr = ^IPMSender;
  296.     IPMSender = RECORD
  297.         sendTag:                IPMSenderTag;
  298.         theSender:                TheSender;
  299.     END;
  300.  
  301. {****************************************************************************}
  302. { Definitions specific to OCEMessaging }
  303.     IPMContextRef                        = LONGINT;
  304.     IPMQueueRef                            = LONGINT;
  305.     IPMMsgRef                            = LONGINT;
  306.     IPMSeqNum                            = LONGINT;
  307.     IPMProcHint                            = Str32;
  308.     IPMQueueName                        = Str32;
  309.     IPMNoteProcPtr = ProcPtr;  { PROCEDURE IPMNote(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT); }
  310.  
  311.     IPMNoteUPP = UniversalProcPtr;
  312.  
  313. CONST
  314.     uppIPMNoteProcInfo = $000037C0;
  315.  
  316. FUNCTION NewIPMNoteProc(userRoutine: IPMNoteProcPtr): IPMNoteUPP;
  317.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  318.     INLINE $2E9F;
  319.     {$ENDC}
  320.  
  321. PROCEDURE CallIPMNoteProc(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT; userRoutine: IPMNoteUPP);
  322.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  323.     INLINE $205F, $4E90;
  324.     {$ENDC}
  325.  
  326. TYPE
  327.     IPMFixedHdrInfoPtr = ^IPMFixedHdrInfo;
  328.     IPMFixedHdrInfo = RECORD
  329.         version:                INTEGER;
  330.         authenticated:            BOOLEAN;
  331.         signatureEnclosed:        BOOLEAN;                                {   digital signature enclosed  }
  332.         msgSize:                LONGINT;
  333.         notification:            SInt8;
  334.         priority:                SInt8;
  335.         blockCount:                INTEGER;
  336.         originalRcptCount:        INTEGER;                                {         original number of recipients  }
  337.         refCon:                    LONGINT;                                {         Client defined data  }
  338.         reserved:                INTEGER;
  339.         creationTime:            UTCTime;                                {         Time when it was created  }
  340.         msgID:                    IPMMsgID;
  341.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  342.     END;
  343.  
  344.  
  345. CONST
  346.     kIPMDeliveryNotificationBit    = 0;
  347.     kIPMNonDeliveryNotificationBit = 1;
  348.     kIPMEncloseOriginalBit        = 2;
  349.     kIPMSummaryReportBit        = 3;                            {  modify enclose original to only on error  }
  350.     kIPMOriginalOnlyOnErrorBit    = 4;
  351.  
  352.     kIPMNoNotificationMask        = $00;
  353.     kIPMDeliveryNotificationMask = $01;
  354.     kIPMNonDeliveryNotificationMask = $02;
  355.     kIPMDontEncloseOriginalMask    = $00;
  356.     kIPMEncloseOriginalMask        = $04;
  357.     kIPMImmediateReportMask        = $00;
  358.     kIPMSummaryReportMask        = $08;
  359.     kIPMOriginalOnlyOnErrorMask    = $10;
  360.     kIPMEncloseOriginalOnErrorMask = $14;
  361.  
  362. { standard Non delivery codes }
  363.     kIPMNoSuchRecipient            = $0001;
  364.     kIPMRecipientMalformed        = $0002;
  365.     kIPMRecipientAmbiguous        = $0003;
  366.     kIPMRecipientAccessDenied    = $0004;
  367.     kIPMGroupExpansionProblem    = $0005;
  368.     kIPMMsgUnreadable            = $0006;
  369.     kIPMMsgExpired                = $0007;
  370.     kIPMMsgNoTranslatableContent = $0008;
  371.     kIPMRecipientReqStdCont        = $0009;
  372.     kIPMRecipientReqSnapShot    = $000A;
  373.     kIPMNoTransferDiskFull        = $000B;
  374.     kIPMNoTransferMsgRejectedbyDest = $000C;
  375.     kIPMNoTransferMsgTooLarge    = $000D;
  376.  
  377. {***********************************************************************}
  378. {
  379. This is the structure that will be returned by enumerate and getmsginfo
  380. This definition is just to give you a template, the position of msgType
  381. is variable since this is a packed structure.  procHint and msgType are
  382. packed and even length padded.
  383.  
  384. * master message info }
  385.  
  386. TYPE
  387.     IPMMsgInfoPtr = ^IPMMsgInfo;
  388.     IPMMsgInfo = RECORD
  389.         sequenceNum:            IPMSeqNum;
  390.         userData:                LONGINT;
  391.         respIndex:                INTEGER;
  392.         padByte:                SInt8;
  393.         priority:                SInt8;
  394.         msgSize:                LONGINT;
  395.         originalRcptCount:        INTEGER;
  396.         reserved:                INTEGER;
  397.         creationTime:            UTCTime;
  398.         msgID:                    IPMMsgID;
  399.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  400.         procHint:                IPMProcHint;
  401.         filler2:                SInt8;
  402.         msgType:                IPMMsgType;
  403.     END;
  404.  
  405.     IPMBlockType                        = OCECreatorType;
  406.     IPMBlockTypePtr                     = ^IPMBlockType;
  407.     IPMTOCPtr = ^IPMTOC;
  408.     IPMTOC = RECORD
  409.         blockType:                IPMBlockType;
  410.         blockOffset:            LONGINT;
  411.         blockSize:                LONGINT;
  412.         blockRefCon:            LONGINT;
  413.     END;
  414.  
  415. {
  416. The following structure is just to describe the layout of the SingleFilter.
  417. Each field should be packed and word aligned when passed to the IPM ToolBox.
  418. }
  419.     IPMSingleFilterPtr = ^IPMSingleFilter;
  420.     IPMSingleFilter = RECORD
  421.         priority:                SInt8;
  422.         padByte:                SInt8;
  423.         family:                    OSType;                                    {  family this msg belongs (e.g. mail), '????' for all  }
  424.         script:                    ScriptCode;                                {  Language Identifier  }
  425.         hint:                    IPMProcHint;
  426.         filler2:                SInt8;
  427.         msgType:                IPMMsgType;
  428.     END;
  429.  
  430.     IPMFilterPtr = ^IPMFilter;
  431.     IPMFilter = RECORD
  432.         count:                    INTEGER;
  433.         sFilters:                ARRAY [0..0] OF IPMSingleFilter;
  434.     END;
  435.  
  436. {************************************************************************
  437. Following structures define the “start” of a recipient report block and the
  438. elements of the array respectively.
  439. }
  440.     IPMReportBlockHeaderPtr = ^IPMReportBlockHeader;
  441.     IPMReportBlockHeader = RECORD
  442.         msgID:                    IPMMsgID;                                {  message id of the original  }
  443.         creationTime:            UTCTime;                                {  creation time of the report  }
  444.     END;
  445.  
  446.     OCERecipientReportPtr = ^OCERecipientReport;
  447.     OCERecipientReport = RECORD
  448.         rcptIndex:                INTEGER;                                {  index of recipient in original message  }
  449.         result:                    OSErr;                                    {  result of sending letter to this recipient }
  450.     END;
  451.  
  452. {***********************************************************************}
  453.     IPMParamBlockPtr = ^IPMParamBlock;
  454.     IPMIOCompletionProcPtr = Register68kProcPtr;  { PROCEDURE IPMIOCompletion(paramBlock: IPMParamBlockPtr); }
  455.  
  456.     IPMIOCompletionUPP = UniversalProcPtr;
  457.     IPMOpenContextPBPtr = ^IPMOpenContextPB;
  458.     IPMOpenContextPB = RECORD
  459.         qLink:                    Ptr;
  460.         reservedH1:                LONGINT;
  461.         reservedH2:                LONGINT;
  462.         ioCompletion:            IPMIOCompletionUPP;
  463.         ioResult:                OSErr;
  464.         saveA5:                    LONGINT;
  465.         reqCode:                INTEGER;
  466.         contextRef:                IPMContextRef;                            {  <--  Context reference to be used in further calls }
  467.     END;
  468.  
  469.     IPMCloseContextPB                    = IPMOpenContextPB;
  470.     IPMCloseContextPBPtr                 = ^IPMCloseContextPB;
  471.     IPMCreateQueuePBPtr = ^IPMCreateQueuePB;
  472.     IPMCreateQueuePB = RECORD
  473.         qLink:                    Ptr;
  474.         reservedH1:                LONGINT;
  475.         reservedH2:                LONGINT;
  476.         ioCompletion:            IPMIOCompletionUPP;
  477.         ioResult:                OSErr;
  478.         saveA5:                    LONGINT;
  479.         reqCode:                INTEGER;
  480.         filler1:                LONGINT;
  481.         queue:                    OCERecipientPtr;
  482.         identity:                AuthIdentity;                            {  used only if queue is remote  }
  483.         owner:                    PackedRecordIDPtr;                        {  used only if queue is remote  }
  484.     END;
  485.  
  486. { For createqueue and deletequeue only queue and identity are used }
  487.     IPMDeleteQueuePB                    = IPMCreateQueuePB;
  488.     IPMDeleteQueuePBPtr                 = ^IPMDeleteQueuePB;
  489.     IPMOpenQueuePBPtr = ^IPMOpenQueuePB;
  490.     IPMOpenQueuePB = RECORD
  491.         qLink:                    Ptr;
  492.         reservedH1:                LONGINT;
  493.         reservedH2:                LONGINT;
  494.         ioCompletion:            IPMIOCompletionUPP;
  495.         ioResult:                OSErr;
  496.         saveA5:                    LONGINT;
  497.         reqCode:                INTEGER;
  498.         contextRef:                IPMContextRef;
  499.         queue:                    OCERecipientPtr;
  500.         identity:                AuthIdentity;
  501.         filter:                    IPMFilterPtr;
  502.         newQueueRef:            IPMQueueRef;
  503.         notificationProc:        IPMNoteUPP;
  504.         userData:                LONGINT;
  505.         noteType:                SInt8;
  506.         padByte:                SInt8;
  507.         reserved:                LONGINT;
  508.         reserved2:                LONGINT;
  509.     END;
  510.  
  511.     IPMCloseQueuePBPtr = ^IPMCloseQueuePB;
  512.     IPMCloseQueuePB = RECORD
  513.         qLink:                    Ptr;
  514.         reservedH1:                LONGINT;
  515.         reservedH2:                LONGINT;
  516.         ioCompletion:            IPMIOCompletionUPP;
  517.         ioResult:                OSErr;
  518.         saveA5:                    LONGINT;
  519.         reqCode:                INTEGER;
  520.         queueRef:                IPMQueueRef;
  521.     END;
  522.  
  523.     IPMEnumerateQueuePBPtr = ^IPMEnumerateQueuePB;
  524.     IPMEnumerateQueuePB = RECORD
  525.         qLink:                    Ptr;
  526.         reservedH1:                LONGINT;
  527.         reservedH2:                LONGINT;
  528.         ioCompletion:            IPMIOCompletionUPP;
  529.         ioResult:                OSErr;
  530.         saveA5:                    LONGINT;
  531.         reqCode:                INTEGER;
  532.         queueRef:                IPMQueueRef;
  533.         startSeqNum:            IPMSeqNum;
  534.         getProcHint:            BOOLEAN;
  535.         getMsgType:                BOOLEAN;
  536.         filler:                    INTEGER;
  537.         filter:                    IPMFilterPtr;
  538.         numToGet:                INTEGER;
  539.         numGotten:                INTEGER;
  540.         enumCount:                LONGINT;
  541.         enumBuffer:                Ptr;                                    {  will be packed array of IPMMsgInfo  }
  542.         actEnumCount:            LONGINT;
  543.     END;
  544.  
  545.     IPMChangeQueueFilterPB                = IPMEnumerateQueuePB;
  546.     IPMChangeQueueFilterPBPtr             = ^IPMChangeQueueFilterPB;
  547.     IPMDeleteMsgRangePBPtr = ^IPMDeleteMsgRangePB;
  548.     IPMDeleteMsgRangePB = RECORD
  549.         qLink:                    Ptr;
  550.         reservedH1:                LONGINT;
  551.         reservedH2:                LONGINT;
  552.         ioCompletion:            IPMIOCompletionUPP;
  553.         ioResult:                OSErr;
  554.         saveA5:                    LONGINT;
  555.         reqCode:                INTEGER;
  556.         queueRef:                IPMQueueRef;
  557.         startSeqNum:            IPMSeqNum;
  558.         endSeqNum:                IPMSeqNum;
  559.         lastSeqNum:                IPMSeqNum;
  560.     END;
  561.  
  562.  
  563.     IPMOpenMsgPBPtr = ^IPMOpenMsgPB;
  564.     IPMOpenMsgPB = RECORD
  565.         qLink:                    Ptr;
  566.         reservedH1:                LONGINT;
  567.         reservedH2:                LONGINT;
  568.         ioCompletion:            IPMIOCompletionUPP;
  569.         ioResult:                OSErr;
  570.         saveA5:                    LONGINT;
  571.         reqCode:                INTEGER;
  572.         queueRef:                IPMQueueRef;
  573.         sequenceNum:            IPMSeqNum;
  574.         newMsgRef:                IPMMsgRef;
  575.         actualSeqNum:            IPMSeqNum;
  576.         exactMatch:                BOOLEAN;
  577.         padByte:                SInt8;
  578.         reserved:                LONGINT;
  579.     END;
  580.  
  581.  
  582.     IPMOpenHFSMsgPBPtr = ^IPMOpenHFSMsgPB;
  583.     IPMOpenHFSMsgPB = RECORD
  584.         qLink:                    Ptr;
  585.         reservedH1:                LONGINT;
  586.         reservedH2:                LONGINT;
  587.         ioCompletion:            IPMIOCompletionUPP;
  588.         ioResult:                OSErr;
  589.         saveA5:                    LONGINT;
  590.         reqCode:                INTEGER;
  591.         hfsPath:                FSSpecPtr;
  592.         filler:                    LONGINT;
  593.         newMsgRef:                IPMMsgRef;
  594.         filler2:                LONGINT;
  595.         filler3:                SInt8;
  596.         filler4:                BOOLEAN;
  597.         reserved:                LONGINT;
  598.     END;
  599.  
  600.  
  601.     IPMOpenBlockAsMsgPBPtr = ^IPMOpenBlockAsMsgPB;
  602.     IPMOpenBlockAsMsgPB = RECORD
  603.         qLink:                    Ptr;
  604.         reservedH1:                LONGINT;
  605.         reservedH2:                LONGINT;
  606.         ioCompletion:            IPMIOCompletionUPP;
  607.         ioResult:                OSErr;
  608.         saveA5:                    LONGINT;
  609.         reqCode:                INTEGER;
  610.         msgRef:                    IPMMsgRef;
  611.         filler:                    LONGINT;
  612.         newMsgRef:                IPMMsgRef;
  613.         filler2:                ARRAY [0..6] OF INTEGER;
  614.         blockIndex:                INTEGER;
  615.     END;
  616.  
  617.  
  618.     IPMCloseMsgPBPtr = ^IPMCloseMsgPB;
  619.     IPMCloseMsgPB = RECORD
  620.         qLink:                    Ptr;
  621.         reservedH1:                LONGINT;
  622.         reservedH2:                LONGINT;
  623.         ioCompletion:            IPMIOCompletionUPP;
  624.         ioResult:                OSErr;
  625.         saveA5:                    LONGINT;
  626.         reqCode:                INTEGER;
  627.         msgRef:                    IPMMsgRef;
  628.         deleteMsg:                BOOLEAN;
  629.         filler1:                BOOLEAN;
  630.     END;
  631.  
  632.  
  633.     IPMGetMsgInfoPBPtr = ^IPMGetMsgInfoPB;
  634.     IPMGetMsgInfoPB = RECORD
  635.         qLink:                    Ptr;
  636.         reservedH1:                LONGINT;
  637.         reservedH2:                LONGINT;
  638.         ioCompletion:            IPMIOCompletionUPP;
  639.         ioResult:                OSErr;
  640.         saveA5:                    LONGINT;
  641.         reqCode:                INTEGER;
  642.         msgRef:                    IPMMsgRef;
  643.         info:                    IPMMsgInfoPtr;
  644.     END;
  645.  
  646.  
  647.     IPMReadHeaderPBPtr = ^IPMReadHeaderPB;
  648.     IPMReadHeaderPB = RECORD
  649.         qLink:                    Ptr;
  650.         reservedH1:                LONGINT;
  651.         reservedH2:                LONGINT;
  652.         ioCompletion:            IPMIOCompletionUPP;
  653.         ioResult:                OSErr;
  654.         saveA5:                    LONGINT;
  655.         reqCode:                INTEGER;
  656.         msgRef:                    IPMMsgRef;
  657.         fieldSelector:            INTEGER;
  658.         offset:                    LONGINT;
  659.         count:                    LONGINT;
  660.         buffer:                    Ptr;
  661.         actualCount:            LONGINT;
  662.         filler:                    INTEGER;
  663.         remaining:                LONGINT;
  664.     END;
  665.  
  666.  
  667.     IPMReadRecipientPBPtr = ^IPMReadRecipientPB;
  668.     IPMReadRecipientPB = RECORD
  669.         qLink:                    Ptr;
  670.         reservedH1:                LONGINT;
  671.         reservedH2:                LONGINT;
  672.         ioCompletion:            IPMIOCompletionUPP;
  673.         ioResult:                OSErr;
  674.         saveA5:                    LONGINT;
  675.         reqCode:                INTEGER;
  676.         msgRef:                    IPMMsgRef;
  677.         rcptIndex:                INTEGER;
  678.         offset:                    LONGINT;
  679.         count:                    LONGINT;
  680.         buffer:                    Ptr;
  681.         actualCount:            LONGINT;
  682.         reserved:                INTEGER;                                {  must be zero  }
  683.         remaining:                LONGINT;
  684.         originalIndex:            INTEGER;
  685.         recipientOffsetFlags:    SInt8;
  686.         filler1:                BOOLEAN;
  687.     END;
  688.  
  689.  
  690. {
  691. replyQueue works like recipient. [can no longer read it via ReadHeader]
  692. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  693. currently none defined.
  694. }
  695.     IPMReadReplyQueuePB                    = IPMReadRecipientPB;
  696.     IPMReadReplyQueuePBPtr                 = ^IPMReadReplyQueuePB;
  697.     IPMGetBlkIndexPBPtr = ^IPMGetBlkIndexPB;
  698.     IPMGetBlkIndexPB = RECORD
  699.         qLink:                    Ptr;
  700.         reservedH1:                LONGINT;
  701.         reservedH2:                LONGINT;
  702.         ioCompletion:            IPMIOCompletionUPP;
  703.         ioResult:                OSErr;
  704.         saveA5:                    LONGINT;
  705.         reqCode:                INTEGER;
  706.         msgRef:                    IPMMsgRef;
  707.         blockType:                IPMBlockType;
  708.         index:                    INTEGER;
  709.         startingFrom:            INTEGER;
  710.         actualBlockType:        IPMBlockType;
  711.         actualBlockIndex:        INTEGER;
  712.     END;
  713.  
  714.  
  715.     IPMReadMsgPBPtr = ^IPMReadMsgPB;
  716.     IPMReadMsgPB = RECORD
  717.         qLink:                    Ptr;
  718.         reservedH1:                LONGINT;
  719.         reservedH2:                LONGINT;
  720.         ioCompletion:            IPMIOCompletionUPP;
  721.         ioResult:                OSErr;
  722.         saveA5:                    LONGINT;
  723.         reqCode:                INTEGER;
  724.         msgRef:                    IPMMsgRef;
  725.         mode:                    IPMAccessMode;
  726.         offset:                    LONGINT;
  727.         count:                    LONGINT;
  728.         buffer:                    Ptr;
  729.         actualCount:            LONGINT;
  730.         blockIndex:                INTEGER;
  731.         remaining:                LONGINT;
  732.     END;
  733.  
  734.     IPMVerifySignaturePBPtr = ^IPMVerifySignaturePB;
  735.     IPMVerifySignaturePB = RECORD
  736.         qLink:                    Ptr;
  737.         reservedH1:                LONGINT;
  738.         reservedH2:                LONGINT;
  739.         ioCompletion:            IPMIOCompletionUPP;
  740.         ioResult:                OSErr;
  741.         saveA5:                    LONGINT;
  742.         reqCode:                INTEGER;
  743.         msgRef:                    IPMMsgRef;
  744.         signatureContext:        SIGContextPtr;
  745.     END;
  746.  
  747.     IPMNewMsgPBPtr = ^IPMNewMsgPB;
  748.     IPMNewMsgPB = RECORD
  749.         qLink:                    Ptr;
  750.         reservedH1:                LONGINT;
  751.         reservedH2:                LONGINT;
  752.         ioCompletion:            IPMIOCompletionUPP;
  753.         ioResult:                OSErr;
  754.         saveA5:                    LONGINT;
  755.         reqCode:                INTEGER;
  756.         filler:                    LONGINT;
  757.         recipient:                OCERecipientPtr;
  758.         replyQueue:                OCERecipientPtr;
  759.         procHint:                StringPtr;
  760.         filler2:                INTEGER;
  761.         msgType:                IPMMsgTypePtr;
  762.         refCon:                    LONGINT;
  763.         newMsgRef:                IPMMsgRef;
  764.         filler3:                INTEGER;
  765.         filler4:                LONGINT;
  766.         identity:                AuthIdentity;
  767.         sender:                    IPMSenderPtr;
  768.         internalUse:            LONGINT;
  769.         internalUse2:            LONGINT;
  770.     END;
  771.  
  772.     IPMNewHFSMsgPBPtr = ^IPMNewHFSMsgPB;
  773.     IPMNewHFSMsgPB = RECORD
  774.         qLink:                    Ptr;
  775.         reservedH1:                LONGINT;
  776.         reservedH2:                LONGINT;
  777.         ioCompletion:            IPMIOCompletionUPP;
  778.         ioResult:                OSErr;
  779.         saveA5:                    LONGINT;
  780.         reqCode:                INTEGER;
  781.         hfsPath:                FSSpecPtr;
  782.         recipient:                OCERecipientPtr;
  783.         replyQueue:                OCERecipientPtr;
  784.         procHint:                StringPtr;
  785.         filler2:                INTEGER;
  786.         msgType:                IPMMsgTypePtr;
  787.         refCon:                    LONGINT;
  788.         newMsgRef:                IPMMsgRef;
  789.         filler3:                INTEGER;
  790.         filler4:                LONGINT;
  791.         identity:                AuthIdentity;
  792.         sender:                    IPMSenderPtr;
  793.         internalUse:            LONGINT;
  794.         internalUse2:            LONGINT;
  795.     END;
  796.  
  797.     IPMNestMsgPBPtr = ^IPMNestMsgPB;
  798.     IPMNestMsgPB = RECORD
  799.         qLink:                    Ptr;
  800.         reservedH1:                LONGINT;
  801.         reservedH2:                LONGINT;
  802.         ioCompletion:            IPMIOCompletionUPP;
  803.         ioResult:                OSErr;
  804.         saveA5:                    LONGINT;
  805.         reqCode:                INTEGER;
  806.         msgRef:                    IPMMsgRef;
  807.         filler:                    ARRAY [0..8] OF INTEGER;
  808.         refCon:                    LONGINT;
  809.         msgToNest:                IPMMsgRef;
  810.         filler2:                INTEGER;
  811.         startingOffset:            LONGINT;
  812.     END;
  813.  
  814.  
  815.     IPMNewNestedMsgBlockPBPtr = ^IPMNewNestedMsgBlockPB;
  816.     IPMNewNestedMsgBlockPB = RECORD
  817.         qLink:                    Ptr;
  818.         reservedH1:                LONGINT;
  819.         reservedH2:                LONGINT;
  820.         ioCompletion:            IPMIOCompletionUPP;
  821.         ioResult:                OSErr;
  822.         saveA5:                    LONGINT;
  823.         reqCode:                INTEGER;
  824.         msgRef:                    IPMMsgRef;
  825.         recipient:                OCERecipientPtr;
  826.         replyQueue:                OCERecipientPtr;
  827.         procHint:                StringPtr;
  828.         filler1:                INTEGER;
  829.         msgType:                IPMMsgTypePtr;
  830.         refCon:                    LONGINT;
  831.         newMsgRef:                IPMMsgRef;
  832.         filler2:                INTEGER;
  833.         startingOffset:            LONGINT;
  834.         identity:                AuthIdentity;
  835.         sender:                    IPMSenderPtr;
  836.         internalUse:            LONGINT;
  837.         internalUse2:            LONGINT;
  838.     END;
  839.  
  840.  
  841.     IPMEndMsgPBPtr = ^IPMEndMsgPB;
  842.     IPMEndMsgPB = RECORD
  843.         qLink:                    Ptr;
  844.         reservedH1:                LONGINT;
  845.         reservedH2:                LONGINT;
  846.         ioCompletion:            IPMIOCompletionUPP;
  847.         ioResult:                OSErr;
  848.         saveA5:                    LONGINT;
  849.         reqCode:                INTEGER;
  850.         msgRef:                    IPMMsgRef;
  851.         msgID:                    IPMMsgID;
  852.         msgTitle:                RStringPtr;
  853.         deliveryNotification:    SInt8;
  854.         priority:                SInt8;
  855.         cancel:                    BOOLEAN;
  856.         padByte:                SInt8;
  857.         reserved:                LONGINT;
  858.         signature:                SIGSignaturePtr;
  859.         signatureSize:            Size;
  860.         signatureContext:        SIGContextPtr;
  861.                                                                         {  family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default  }
  862.         family:                    OSType;
  863.     END;
  864.  
  865.  
  866.     IPMAddRecipientPBPtr = ^IPMAddRecipientPB;
  867.     IPMAddRecipientPB = RECORD
  868.         qLink:                    Ptr;
  869.         reservedH1:                LONGINT;
  870.         reservedH2:                LONGINT;
  871.         ioCompletion:            IPMIOCompletionUPP;
  872.         ioResult:                OSErr;
  873.         saveA5:                    LONGINT;
  874.         reqCode:                INTEGER;
  875.         msgRef:                    IPMMsgRef;
  876.         recipient:                OCERecipientPtr;
  877.         reserved:                LONGINT;
  878.     END;
  879.  
  880.  
  881.     IPMAddReplyQueuePBPtr = ^IPMAddReplyQueuePB;
  882.     IPMAddReplyQueuePB = RECORD
  883.         qLink:                    Ptr;
  884.         reservedH1:                LONGINT;
  885.         reservedH2:                LONGINT;
  886.         ioCompletion:            IPMIOCompletionUPP;
  887.         ioResult:                OSErr;
  888.         saveA5:                    LONGINT;
  889.         reqCode:                INTEGER;
  890.         msgRef:                    IPMMsgRef;
  891.         filler:                    LONGINT;
  892.         replyQueue:                OCERecipientPtr;
  893.     END;
  894.  
  895.  
  896.     IPMNewBlockPBPtr = ^IPMNewBlockPB;
  897.     IPMNewBlockPB = RECORD
  898.         qLink:                    Ptr;
  899.         reservedH1:                LONGINT;
  900.         reservedH2:                LONGINT;
  901.         ioCompletion:            IPMIOCompletionUPP;
  902.         ioResult:                OSErr;
  903.         saveA5:                    LONGINT;
  904.         reqCode:                INTEGER;
  905.         msgRef:                    IPMMsgRef;
  906.         blockType:                IPMBlockType;
  907.         filler:                    ARRAY [0..4] OF INTEGER;
  908.         refCon:                    LONGINT;
  909.         filler2:                ARRAY [0..2] OF INTEGER;
  910.         startingOffset:            LONGINT;
  911.     END;
  912.  
  913.  
  914.     IPMWriteMsgPBPtr = ^IPMWriteMsgPB;
  915.     IPMWriteMsgPB = RECORD
  916.         qLink:                    Ptr;
  917.         reservedH1:                LONGINT;
  918.         reservedH2:                LONGINT;
  919.         ioCompletion:            IPMIOCompletionUPP;
  920.         ioResult:                OSErr;
  921.         saveA5:                    LONGINT;
  922.         reqCode:                INTEGER;
  923.         msgRef:                    IPMMsgRef;
  924.         mode:                    IPMAccessMode;
  925.         offset:                    LONGINT;
  926.         count:                    LONGINT;
  927.         buffer:                    Ptr;
  928.         actualCount:            LONGINT;
  929.         currentBlock:            BOOLEAN;
  930.         filler1:                BOOLEAN;
  931.     END;
  932.  
  933.  
  934.  
  935.     IPMParamBlock = RECORD
  936.         CASE INTEGER OF
  937.         0: (
  938.             qLink:                Ptr;
  939.             reservedH1:            LONGINT;
  940.             reservedH2:            LONGINT;
  941.             ioCompletion:        IPMIOCompletionUPP;
  942.             ioResult:            OSErr;
  943.             saveA5:                LONGINT;
  944.             reqCode:            INTEGER;
  945.            );
  946.         1: (
  947.             openContextPB:        IPMOpenContextPB;
  948.             );
  949.         2: (
  950.             closeContextPB:        IPMCloseContextPB;
  951.             );
  952.         3: (
  953.             createQueuePB:        IPMCreateQueuePB;
  954.             );
  955.         4: (
  956.             deleteQueuePB:        IPMDeleteQueuePB;
  957.             );
  958.         5: (
  959.             openQueuePB:        IPMOpenQueuePB;
  960.             );
  961.         6: (
  962.             closeQueuePB:        IPMCloseQueuePB;
  963.             );
  964.         7: (
  965.             enumerateQueuePB:    IPMEnumerateQueuePB;
  966.             );
  967.         8: (
  968.             changeQueueFilterPB: IPMChangeQueueFilterPB;
  969.             );
  970.         9: (
  971.             deleteMsgRangePB:    IPMDeleteMsgRangePB;
  972.             );
  973.         10: (
  974.             openMsgPB:            IPMOpenMsgPB;
  975.             );
  976.         11: (
  977.             openHFSMsgPB:        IPMOpenHFSMsgPB;
  978.             );
  979.         12: (
  980.             openBlockAsMsgPB:    IPMOpenBlockAsMsgPB;
  981.             );
  982.         13: (
  983.             closeMsgPB:            IPMCloseMsgPB;
  984.             );
  985.         14: (
  986.             getMsgInfoPB:        IPMGetMsgInfoPB;
  987.             );
  988.         15: (
  989.             readHeaderPB:        IPMReadHeaderPB;
  990.             );
  991.         16: (
  992.             readRecipientPB:    IPMReadRecipientPB;
  993.             );
  994.         17: (
  995.             readReplyQueuePB:    IPMReadReplyQueuePB;
  996.             );
  997.         18: (
  998.             getBlkIndexPB:        IPMGetBlkIndexPB;
  999.             );
  1000.         19: (
  1001.             readMsgPB:            IPMReadMsgPB;
  1002.             );
  1003.         20: (
  1004.             verifySignaturePB:    IPMVerifySignaturePB;
  1005.             );
  1006.         21: (
  1007.             newMsgPB:            IPMNewMsgPB;
  1008.             );
  1009.         22: (
  1010.             newHFSMsgPB:        IPMNewHFSMsgPB;
  1011.             );
  1012.         23: (
  1013.             nestMsgPB:            IPMNestMsgPB;
  1014.             );
  1015.         24: (
  1016.             newNestedMsgBlockPB: IPMNewNestedMsgBlockPB;
  1017.             );
  1018.         25: (
  1019.             endMsgPB:            IPMEndMsgPB;
  1020.             );
  1021.         26: (
  1022.             addRecipientPB:        IPMAddRecipientPB;
  1023.             );
  1024.         27: (
  1025.             addReplyQueuePB:    IPMAddReplyQueuePB;
  1026.             );
  1027.         28: (
  1028.             newBlockPB:            IPMNewBlockPB;
  1029.             );
  1030.         29: (
  1031.             writeMsgPB:            IPMWriteMsgPB;
  1032.             );
  1033.     END;
  1034.  
  1035.  
  1036. CONST
  1037.     uppIPMIOCompletionProcInfo = $00009802;
  1038.  
  1039. PROCEDURE CallIPMIOCompletionProc(paramBlock: IPMParamBlockPtr; userRoutine: IPMIOCompletionUPP);
  1040.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1041.     {To be implemented:  Glue to move parameters into registers.}
  1042.     {$ENDC}
  1043.  
  1044. FUNCTION NewIPMIOCompletionProc(userRoutine: IPMIOCompletionProcPtr): IPMIOCompletionUPP;
  1045.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1046.     INLINE $2E9F;
  1047.     {$ENDC}
  1048. FUNCTION IPMOpenContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1049.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1050.     INLINE $3F3C, $0400, $AA5E;
  1051.     {$ENDC}
  1052. FUNCTION IPMCloseContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1053.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1054.     INLINE $3F3C, $0401, $AA5E;
  1055.     {$ENDC}
  1056. FUNCTION IPMNewMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1057.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1058.     INLINE $3F3C, $0402, $AA5E;
  1059.     {$ENDC}
  1060. FUNCTION IPMNewBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1061.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1062.     INLINE $3F3C, $0404, $AA5E;
  1063.     {$ENDC}
  1064. FUNCTION IPMNewNestedMsgBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1065.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1066.     INLINE $3F3C, $0405, $AA5E;
  1067.     {$ENDC}
  1068. FUNCTION IPMNestMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1069.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1070.     INLINE $3F3C, $0406, $AA5E;
  1071.     {$ENDC}
  1072. FUNCTION IPMWriteMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1073.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1074.     INLINE $3F3C, $0407, $AA5E;
  1075.     {$ENDC}
  1076. FUNCTION IPMEndMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1077.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1078.     INLINE $3F3C, $0408, $AA5E;
  1079.     {$ENDC}
  1080. FUNCTION IPMOpenQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1081.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1082.     INLINE $3F3C, $0409, $AA5E;
  1083.     {$ENDC}
  1084. FUNCTION IPMCloseQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1085.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1086.     INLINE $3F3C, $040A, $AA5E;
  1087.     {$ENDC}
  1088. { Always synchronous }
  1089. FUNCTION IPMVerifySignature(paramBlock: IPMParamBlockPtr): OSErr;
  1090.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1091.     INLINE $7000, $1F00, $3F3C, $0422, $AA5E;
  1092.     {$ENDC}
  1093. FUNCTION IPMOpenMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1094.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1095.     INLINE $3F3C, $040B, $AA5E;
  1096.     {$ENDC}
  1097. FUNCTION IPMCloseMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1098.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1099.     INLINE $3F3C, $040C, $AA5E;
  1100.     {$ENDC}
  1101. FUNCTION IPMReadMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1102.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1103.     INLINE $3F3C, $040D, $AA5E;
  1104.     {$ENDC}
  1105. FUNCTION IPMReadHeader(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1106.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1107.     INLINE $3F3C, $040E, $AA5E;
  1108.     {$ENDC}
  1109. FUNCTION IPMOpenBlockAsMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1110.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1111.     INLINE $3F3C, $040F, $AA5E;
  1112.     {$ENDC}
  1113. FUNCTION IPMNewHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1114.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1115.     INLINE $3F3C, $041E, $AA5E;
  1116.     {$ENDC}
  1117. FUNCTION IPMReadRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1118.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1119.     INLINE $3F3C, $0410, $AA5E;
  1120.     {$ENDC}
  1121. FUNCTION IPMReadReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1122.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1123.     INLINE $3F3C, $0421, $AA5E;
  1124.     {$ENDC}
  1125. FUNCTION IPMCreateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1126.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1127.     INLINE $3F3C, $0411, $AA5E;
  1128.     {$ENDC}
  1129. FUNCTION IPMDeleteQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1130.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1131.     INLINE $3F3C, $0412, $AA5E;
  1132.     {$ENDC}
  1133. FUNCTION IPMEnumerateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1134.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1135.     INLINE $3F3C, $0413, $AA5E;
  1136.     {$ENDC}
  1137. FUNCTION IPMChangeQueueFilter(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1138.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1139.     INLINE $3F3C, $0414, $AA5E;
  1140.     {$ENDC}
  1141. FUNCTION IPMDeleteMsgRange(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1142.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1143.     INLINE $3F3C, $0415, $AA5E;
  1144.     {$ENDC}
  1145. FUNCTION IPMAddRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1146.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1147.     INLINE $3F3C, $0403, $AA5E;
  1148.     {$ENDC}
  1149. FUNCTION IPMAddReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1150.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1151.     INLINE $3F3C, $041D, $AA5E;
  1152.     {$ENDC}
  1153. FUNCTION IPMOpenHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1154.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1155.     INLINE $3F3C, $0417, $AA5E;
  1156.     {$ENDC}
  1157. FUNCTION IPMGetBlkIndex(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1158.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1159.     INLINE $3F3C, $0418, $AA5E;
  1160.     {$ENDC}
  1161. FUNCTION IPMGetMsgInfo(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1162.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1163.     INLINE $3F3C, $0419, $AA5E;
  1164.     {$ENDC}
  1165.  
  1166.  
  1167. {$ALIGN RESET}
  1168. {$POP}
  1169.  
  1170. {$SETC UsingIncludes := OCEMessagingIncludes}
  1171.  
  1172. {$ENDC} {__OCEMESSAGING__}
  1173.  
  1174. {$IFC NOT UsingIncludes}
  1175.  END.
  1176. {$ENDC}
  1177.